/* istanbul ignore file */
/* tslint:disable */
/* eslint-disable */
import type { ProductInfo } from '../models/ProductInfo';
import { request as __request, checkJsonSchema as __checkJsonSchema } from '../../core/request';
const schemas = require("../schema").default;

export class ProductManagerService {

    /**
     * 用户通过前端添加测试产品
     * @returns any OK
     * @throws ApiError
     */
    public static async addProduct({
        ownerId,
        requestBody,
    }: {
        ownerId: string,
        requestBody?: {
            /**
             * 产品名称
             */
            name: string,
            /**
             * 产品英文名称
             */
            enname: string,
            /**
             * 产品所属项目
             */
            project: string,
            /**
             * 描述
             */
            description?: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 产品入库成功编号
         */
        id: string,
    }> {
        const result = await __request({
            method: 'POST',
            path: `/product-admin/v1/${ownerId}/product`,
            body: requestBody,
        });

        __checkJsonSchema("addProduct", schemas, result);
        return result.body;
    }

    /**
     * 用户通过前端列举自己创建的测试产品
     * @returns any OK
     * @throws ApiError
     */
    public static async getCreatedProducts({
        ownerId,
        requestBody,
    }: {
        ownerId: string,
        requestBody?: {
            /**
             * 产品拥有者
             */
            ownerId: number,
            /**
             * 分页查询的页数
             * 1）不传该参数，查询内容不分页
             * 2）传大于等于1的整数时，分页查询
             */
            pageNum?: number,
            /**
             * 分页查询的每页数据条数，取值范围 1-100。默认提取20条
             */
            pageDataCount?: number,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 产品信息列表
         */
        products: Array<{
            /**
             * 产品ID
             */
            productId: string,
            /**
             * 产品名称
             */
            name: string,
            /**
             * 产品英文名称
             */
            enname: string,
            /**
             * 产品所属项目
             */
            project: string,
            /**
             * 描述
             */
            description?: string,
            /**
             * 创建日期，格式：2021-03-10 18:33:10
             */
            createTime: string,
        }>,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/product-admin/v1/${ownerId}/product`,
            body: requestBody,
        });

        __checkJsonSchema("getCreatedProducts", schemas, result);
        return result.body;
    }

    /**
     * 用户通过前端修改测试产品的基本信息
     * @returns any Example response
     * @throws ApiError
     */
    public static async modProductId({
        ownerId,
        productId,
        requestBody,
    }: {
        ownerId: string,
        productId: string,
        requestBody?: {
            /**
             * 产品拥有者
             */
            ownerId: number,
            /**
             * 产品ID
             */
            productId: string,
            /**
             * 产品名称
             */
            name: string,
            /**
             * 产品英文名称
             */
            enname: string,
            /**
             * 产品所属项目
             */
            project: string,
            /**
             * 描述
             */
            description?: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'PUT',
            path: `/product-admin/v1/${ownerId}/product/${productId}`,
            body: requestBody,
        });

        __checkJsonSchema("modProductId", schemas, result);
        return result.body;
    }

    /**
     * Your GET endpoint
     * 用户通过前端列举参与测试的测试产品
     * @returns any OK
     * @throws ApiError
     */
    public static async getTestProduct({
        userId,
        requestBody,
    }: {
        userId: string,
        requestBody?: {
            /**
             * 用户ID
             */
            userId: number,
            /**
             * 分页查询的页数
             * 1）不传该参数，查询内容不分页
             * 2）传大于等于1的整数时，分页查询
             */
            pageNum?: number,
            /**
             * 分页查询的每页数据条数，取值范围 1-100。默认提取20条
             */
            pageDataCount?: number,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        products?: Array<ProductInfo>,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/product-admin/v1/${userId}/product`,
            body: requestBody,
        });

        __checkJsonSchema("getTestProduct", schemas, result);
        return result.body;
    }

    /**
     * Your GET endpoint
     * 用户通过前端查询某个产品的详情
     * @returns any OK
     * @throws ApiError
     */
    public static async getProductDetail({
        ownerId,
        id,
        requestBody,
    }: {
        ownerId: string,
        id: string,
        requestBody?: {
            /**
             * 拥有者ID
             */
            ownerId: number,
            /**
             * 产品ID
             */
            id: number,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        productInfo: Array<ProductInfo>,
        /**
         * 产品版本结构列表。
         */
        versions: Array<{
            /**
             * 产品版本ID
             */
            versionId: number,
            /**
             * 产品版本号
             */
            version: string,
        }>,
        /**
         * 正在运行的测试任务的列表。
         */
        runningTasks: Array<{
            /**
             * 任务ID
             */
            taskId: number,
            /**
             * 运行人员名称
             */
            operatorName: string,
            /**
             * 发起方式，可取值：web、jenkins
             */
            launchFrom: Array<any>,
            /**
             * 任务开始时间
             */
            startTime: string,
            /**
             * 任务结束时间
             */
            endTime: string,
            /**
             * 运行时长
             */
            duration: string,
            /**
             * 通过率
             */
            passRate: number,
            /**
             * 运行集群的名字
             */
            clusterName: string,
        }>,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/product-admin/v1/${ownerId}/product/${id}`,
            body: requestBody,
        });

        __checkJsonSchema("getProductDetail", schemas, result);
        return result.body;
    }

    /**
     * 用户通过前端删除某个测试产品
     * @returns any Example response
     * @throws ApiError
     */
    public static async deleteProduct({
        ownerId,
        id,
        requestBody,
    }: {
        ownerId: string,
        id: string,
        requestBody?: {
            /**
             * 拥有者ID
             */
            ownerId: number,
            /**
             * 产品ID
             */
            id: number,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'DELETE',
            path: `/product-admin/v1/${ownerId}/api-doc/${id}`,
            body: requestBody,
        });

        __checkJsonSchema("deleteProduct", schemas, result);
        return result.body;
    }

    /**
     * Your GET endpoint
     * 产品管理员查询平台用户
     * @returns any OK
     * @throws ApiError
     */
    public static async getPlatform({
        productId,
        requestBody,
    }: {
        productId: string,
        requestBody?: {
            /**
             * 产品ID
             */
            productId: number,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 团队成员入库成功编号
         */
        productUserList: Array<{
            /**
             * 用户ID
             */
            userId: number,
            /**
             * 用户名
             */
            userName: string,
        }>,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/product-admin/v1/${productId}/user`,
            body: requestBody,
        });

        __checkJsonSchema("getPlatform", schemas, result);
        return result.body;
    }

    /**
     * 用户通过前端添加产品团队成员及其权限
     * @returns any OK
     * @throws ApiError
     */
    public static async addProductMembers({
        productId,
        requestBody,
    }: {
        productId: string,
        requestBody?: {
            /**
             * 产品ID
             */
            productId: number,
            /**
             * 用户ID
             */
            userId: number,
            /**
             * 测试对象编辑权限，可取值：0-无权限，1-有权限
             */
            objectW?: number,
            /**
             * 测试对象查看权限，可取值：0-无权限，1-有权限
             */
            objectR?: number,
            /**
             * 测试需求编辑权限，可取值：0-无权限，1-有权限
             */
            demandW?: number,
            /**
             * 测试需求查看权限，可取值：0-无权限，1-有权限
             */
            demandR?: number,
            /**
             * 测试用例编辑权限，可取值：0-无权限，1-有权限
             */
            caseW?: number,
            /**
             * 测试用例查看权限，可取值：0-无权限，1-有权限
             */
            caseR?: number,
            /**
             * 测试方案编辑权限，可取值：0-无权限，1-有权限
             */
            planW?: number,
            /**
             * 测试方案查看权限，可取值：0-无权限，1-有权限
             */
            planR?: number,
            /**
             * 测试任务运行权限，可取值：0-无权限，1-有权限
             */
            task?: number,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 成员权限ID
         */
        id: number,
    }> {
        const result = await __request({
            method: 'POST',
            path: `/product-admin/v1/${productId}/user`,
            body: requestBody,
        });

        __checkJsonSchema("addProductMembers", schemas, result);
        return result.body;
    }

    /**
     * 用户通过前端修改某个团队成员的权限
     * @returns any Example response
     * @throws ApiError
     */
    public static async modTeamAuth({
        productId,
        userId,
        requestBody,
    }: {
        productId: string,
        userId: string,
        requestBody?: {
            /**
             * 产品ID
             */
            productId: number,
            /**
             * 用户ID
             */
            userId: number,
            /**
             * 测试对象编辑权限，可取值：0-无权限，1-有权限
             */
            objectW?: number,
            /**
             * 测试对象查看权限，可取值：0-无权限，1-有权限
             */
            objectR?: number,
            /**
             * 测试需求编辑权限，可取值：0-无权限，1-有权限
             */
            demandW?: number,
            /**
             * 测试需求查看权限，可取值：0-无权限，1-有权限
             */
            demandR?: number,
            /**
             * 测试用例编辑权限，可取值：0-无权限，1-有权限
             */
            caseW?: number,
            /**
             * 测试用例查看权限，可取值：0-无权限，1-有权限
             */
            caseR?: number,
            /**
             * 测试方案编辑权限，可取值：0-无权限，1-有权限
             */
            planW?: number,
            /**
             * 测试方案查看权限，可取值：0-无权限，1-有权限
             */
            planR?: number,
            /**
             * 测试任务运行权限，可取值：0-无权限，1-有权限
             */
            task?: number,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'PUT',
            path: `/product-admin/v1/${productId}/user/${userId}`,
            body: requestBody,
        });

        __checkJsonSchema("modTeamAuth", schemas, result);
        return result.body;
    }

    /**
     * 查询产品团队成员列表
     * @returns any OK
     * @throws ApiError
     */
    public static async getTeamAuth({
        productId,
        requestBody,
    }: {
        productId: string,
        requestBody?: {
            /**
             * 产品ID
             */
            productId: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 测试团队权限列表
         */
        teamAuths: Array<{
            /**
             * 权限标识ID
             */
            id: number,
            /**
             * 团队成员ID
             */
            userId: number,
            /**
             * 测试对象编辑权限，可取值：0-无权限，1-有权限
             */
            objectW?: number,
            /**
             * 测试对象查看权限，可取值：0-无权限，1-有权限
             */
            objectR?: number,
            /**
             * 测试需求编辑权限，可取值：0-无权限，1-有权限
             */
            demandW?: number,
            /**
             * 测试需求查看权限，可取值：0-无权限，1-有权限
             */
            demandR?: number,
            /**
             * 测试用例编辑权限，可取值：0-无权限，1-有权限
             */
            caseW?: number,
            /**
             * 测试用例查看权限，可取值：0-无权限，1-有权限
             */
            caseR?: number,
            /**
             * 测试方案编辑权限，可取值：0-无权限，1-有权限
             */
            planW?: number,
            /**
             * 测试方案查看权限，可取值：0-无权限，1-有权限
             */
            planR?: number,
            /**
             * 测试任务运行权限，可取值：0-无权限，1-有权限
             */
            task?: number,
        }>,
    }> {
        const result = await __request({
            method: 'POST',
            path: `/product-admin/v1/${productId}/team-auth`,
            body: requestBody,
        });

        __checkJsonSchema("getTeamAuth", schemas, result);
        return result.body;
    }

    /**
     * 用户通过前端创建产品版本
     * @returns any OK
     * @throws ApiError
     */
    public static async addProductVersion({
        productId,
        requestBody,
    }: {
        productId: string,
        requestBody?: {
            /**
             * 产品ID
             */
            productId: number,
            /**
             * 产品号
             */
            version: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 产品版本入库成功编号
         */
        id: string,
    }> {
        const result = await __request({
            method: 'POST',
            path: `/product-admin/v1/${productId}/version`,
            body: requestBody,
        });

        __checkJsonSchema("addProductVersion", schemas, result);
        return result.body;
    }

    /**
     * 用户通过前端导出OpenAPI文档
     * @returns any Example response
     * @throws ApiError
     */
    public static async exportOpenApi({
        productId,
        versionId,
        requestBody,
    }: {
        productId: string,
        versionId: string,
        requestBody?: {
            /**
             * 产品ID
             */
            productId: number,
            /**
             * 产品号
             */
            versionId: number,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'POST',
            path: `/product-admin/v1/${productId}/version/${versionId}`,
            body: requestBody,
        });

        __checkJsonSchema("exportOpenAPI", schemas, result);
        return result.body;
    }

}